518 lines
12 KiB
Go
518 lines
12 KiB
Go
package orm
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"git.andreafazzi.eu/andrea/oef/errors"
|
|
"git.andreafazzi.eu/andrea/oef/renderer"
|
|
"github.com/jinzhu/gorm"
|
|
)
|
|
|
|
type ContestIDs []uint
|
|
|
|
type Participant struct {
|
|
gorm.Model
|
|
|
|
UserModifier
|
|
|
|
UserID uint
|
|
|
|
Firstname string
|
|
Lastname string
|
|
|
|
Password string `gorm:"-"`
|
|
|
|
FiscalCode string
|
|
|
|
CategoryID uint `schema:"category_id"`
|
|
SchoolID uint `schema:"school_id"`
|
|
|
|
User *User
|
|
School *School
|
|
Category *Category
|
|
|
|
Responses []*Response
|
|
|
|
ContestIDs ContestIDs `schema:"contest_ids" gorm:"-"`
|
|
Contests []*Contest `gorm:"many2many:subscriptions"`
|
|
|
|
SelectedCategory map[uint]string `gorm:"-"`
|
|
AllCategories []*Category `gorm:"-"`
|
|
|
|
SelectedContest map[uint]string `gorm:"-"`
|
|
AllContests []*Contest `gorm:"-"`
|
|
|
|
SelectedSchool map[uint]string `gorm:"-"`
|
|
AllSchools []*School `gorm:"-"`
|
|
}
|
|
|
|
func (ids *ContestIDs) UnmarshalCSV(csv string) error {
|
|
splits := strings.Split(csv, ",")
|
|
for _, s := range splits {
|
|
id, err := strconv.Atoi(s)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
*ids = append(*ids, uint(id))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (model *Participant) sanitize(s string) string {
|
|
lower := strings.ToLower(s)
|
|
r := strings.NewReplacer("'", "", "-", "", " ", "", "ò", "o", "ì", "i")
|
|
return r.Replace(lower)
|
|
}
|
|
|
|
func (model *Participant) username() string {
|
|
return strings.ToUpper(model.FiscalCode)
|
|
}
|
|
|
|
func (model *Participant) GetID() uint { return model.ID }
|
|
|
|
func (model *Participant) String() string {
|
|
return fmt.Sprintf("%s %s", strings.ToUpper(model.Lastname), strings.Title(strings.ToLower(model.Firstname)))
|
|
}
|
|
|
|
func (model *Participant) SetCreatorID(id uint) {
|
|
model.CreatorID = id
|
|
}
|
|
|
|
func (model *Participant) SetCreatorRole(role string) {
|
|
model.CreatorRole = role
|
|
}
|
|
|
|
func (model *Participant) SetCreatorIP(addr string) {
|
|
model.CreatorIP = addr
|
|
}
|
|
|
|
func (model *Participant) SetUpdaterID(id uint) {
|
|
model.UpdaterID = id
|
|
}
|
|
|
|
func (model *Participant) SetUpdaterRole(role string) {
|
|
model.UpdaterRole = role
|
|
}
|
|
|
|
func (model *Participant) SetUpdaterIP(addr string) {
|
|
model.UpdaterIP = addr
|
|
}
|
|
|
|
func (model *Participant) exists(db *Database) (*User, error) {
|
|
var user User
|
|
if err := db._db.First(&user, &User{Username: model.username()}).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
return nil, err
|
|
} else if err == gorm.ErrRecordNotFound {
|
|
log.Printf("User %s doesn't exist", user)
|
|
return nil, nil
|
|
}
|
|
|
|
log.Printf("User %s exists", user)
|
|
|
|
return &user, nil
|
|
}
|
|
|
|
func (model *Participant) BeforeSave(tx *gorm.DB) error {
|
|
var user User
|
|
|
|
if err := tx.FirstOrCreate(&user, &User{
|
|
Username: model.username(),
|
|
Password: model.Password,
|
|
Role: "participant",
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
model.UserID = user.ID
|
|
return nil
|
|
}
|
|
|
|
func (model *Participant) AfterSave(tx *gorm.DB) error {
|
|
for _, contest := range model.Contests {
|
|
var response Response
|
|
if err := tx.FirstOrCreate(
|
|
&response,
|
|
&Response{
|
|
Name: fmt.Sprintf("%s (%s)", contest.Name, model.String()),
|
|
ContestID: contest.ID,
|
|
ParticipantID: model.ID,
|
|
}).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
order, err := contest.generateQuestionsOrder(tx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Model(&response).Update("QuestionsOrder", order).Error; err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (model *Participant) AfterDelete(tx *gorm.DB) error {
|
|
if err := tx.Unscoped().Delete(model.User).Error; err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (model *Participant) Create(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
|
|
if r.Method == "GET" {
|
|
participant := new(Participant)
|
|
if isSchool(r) {
|
|
if err := db._db.Find(&participant.AllCategories).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
if err := db._db.Find(&participant.AllCategories).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db._db.Find(&participant.AllContests).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db._db.Find(&participant.AllSchools).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return participant, nil
|
|
} else {
|
|
participant := new(Participant)
|
|
|
|
err := renderer.Decode(participant, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Check if participant exists
|
|
log.Printf("Check if participant %s already exists", participant)
|
|
if user, err := participant.exists(db); err == nil && user != nil {
|
|
// if err := db._db.Where("user_id = ?", user.ID).Find(&participant).Error; err != nil && err != gorm.ErrRecordNotFound {
|
|
// return nil, err
|
|
// }
|
|
return nil, errors.ParticipantExists
|
|
} else if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// If user has "school" role get school id from token
|
|
if isSchool(r) {
|
|
schoolID, err := strconv.Atoi(getModelIDFromToken(r))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
participant.SchoolID = uint(schoolID)
|
|
}
|
|
|
|
// Check if a participant of the same category exists
|
|
var school School
|
|
if participant.SchoolID > 0 {
|
|
if err := db._db.First(&school, participant.SchoolID).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
log.Printf("Check if a participant of the same category exists for school %s", school)
|
|
hasCategory, err := school.HasCategory(db, participant)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if hasCategory {
|
|
return nil, errors.CategoryExists
|
|
}
|
|
}
|
|
|
|
WriteCreator(r, participant)
|
|
|
|
log.Printf("Create participant %s", participant)
|
|
|
|
participant, err = CreateParticipant(db, participant)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// FIXME: Should be managed by API
|
|
if isAdministrator(r) {
|
|
var response Response
|
|
|
|
err := db._db.First(&response, &Response{ParticipantID: participant.ID}).Error
|
|
if err != nil && err != gorm.ErrRecordNotFound {
|
|
return nil, err
|
|
}
|
|
|
|
if err != gorm.ErrRecordNotFound {
|
|
response.CreatorID = getUserIDFromTokenAsUint(r)
|
|
|
|
if err := db._db.Save(&response).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return participant, nil
|
|
}
|
|
}
|
|
|
|
func (model *Participant) Read(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
|
|
var participant Participant
|
|
|
|
id := args["id"]
|
|
|
|
if isParticipant(r) {
|
|
if id != getModelIDFromToken(r) {
|
|
return nil, errors.NotAuthorized
|
|
}
|
|
}
|
|
|
|
// School user can access to its participants only!
|
|
if isSchool(r) {
|
|
if err := db._db.Preload("School").First(&participant, id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if strconv.Itoa(int(participant.SchoolID)) != getModelIDFromToken(r) {
|
|
return nil, errors.NotAuthorized
|
|
}
|
|
|
|
if err := db._db.
|
|
Preload("User").
|
|
Preload("School").
|
|
Preload("School.Participants").
|
|
Preload("Category").
|
|
First(&participant, id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
} else {
|
|
if err := db._db.
|
|
Preload("User").
|
|
Preload("Creator").
|
|
Preload("Updater").
|
|
Preload("School").
|
|
Preload("School.Participants").
|
|
Preload("Responses").
|
|
Preload("Responses.Contest").
|
|
Preload("Contests").
|
|
Preload("Category").
|
|
First(&participant, id).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
}
|
|
|
|
return &participant, nil
|
|
}
|
|
|
|
func (model *Participant) ReadAll(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
|
|
var participants []*Participant
|
|
|
|
// School user can access to its participants only!
|
|
if isSchool(r) {
|
|
schoolId, err := strconv.Atoi(getModelIDFromToken(r))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db._db.
|
|
Preload("Category").
|
|
Preload("School").
|
|
Preload("Contests").
|
|
Order("lastname").
|
|
Find(&participants, &Participant{SchoolID: uint(schoolId)}).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
if err := db._db.
|
|
Preload("Category").
|
|
Preload("School").
|
|
Preload("Contests").
|
|
Preload("Responses").
|
|
Order("created_at").Find(&participants).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return participants, nil
|
|
}
|
|
|
|
func (model *Participant) Update(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
|
|
if r.Method == "GET" {
|
|
result, err := model.Read(db, args, w, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant := result.(*Participant)
|
|
|
|
if isSchool(r) {
|
|
if err := db._db.Find(&participant.AllCategories).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant.SelectedCategory = make(map[uint]string)
|
|
participant.SelectedCategory[participant.CategoryID] = "selected"
|
|
} else {
|
|
if err := db._db.Find(&participant.AllCategories).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant.SelectedCategory = make(map[uint]string)
|
|
participant.SelectedCategory[participant.CategoryID] = "selected"
|
|
|
|
if err := db._db.Find(&participant.AllContests).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant.SelectedContest = make(map[uint]string)
|
|
for _, c := range participant.Contests {
|
|
participant.SelectedContest[c.ID] = "selected"
|
|
}
|
|
|
|
if err := db._db.Find(&participant.AllSchools).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant.SelectedSchool = make(map[uint]string)
|
|
participant.SelectedSchool[participant.SchoolID] = "selected"
|
|
}
|
|
return participant, nil
|
|
} else {
|
|
participant, err := model.Read(db, args, w, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = renderer.Decode(participant, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if user, err := participant.(*Participant).exists(db); err == nil && user != nil {
|
|
if user.ID != participant.(*Participant).UserID {
|
|
return nil, errors.ParticipantExists
|
|
}
|
|
} else if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Check if a participant of the same category exists
|
|
var school School
|
|
if participant.(*Participant).SchoolID > 0 {
|
|
if err := db._db.First(&school, participant.(*Participant).SchoolID).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
hasCategory, err := school.HasCategory(db, participant.(*Participant))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if hasCategory {
|
|
return nil, errors.CategoryExists
|
|
}
|
|
}
|
|
|
|
if err := db._db.
|
|
Where([]uint(participant.(*Participant).ContestIDs)).
|
|
Find(&participant.(*Participant).Contests).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
WriteUpdater(r, participant.(*Participant))
|
|
|
|
_, err = SaveParticipant(db, participant)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if err := db._db.
|
|
Model(participant).
|
|
Association("Contests").
|
|
Replace(participant.(*Participant).Contests).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participant, err = model.Read(db, args, w, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// FIXME: Should be managed by API
|
|
if isAdministrator(r) {
|
|
var response Response
|
|
|
|
err := db._db.First(
|
|
&response,
|
|
&Response{ParticipantID: participant.(*Participant).ID},
|
|
).Error
|
|
if err != nil && err != gorm.ErrRecordNotFound {
|
|
return nil, err
|
|
}
|
|
|
|
if err != gorm.ErrRecordNotFound {
|
|
response.UpdaterID = getUserIDFromTokenAsUint(r)
|
|
|
|
if err := db._db.Save(&response).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Delete responses for unsubscribed participants
|
|
|
|
var found bool
|
|
toBeDeletedResponses := make([]*Response, 0)
|
|
for _, response := range participant.(*Participant).Responses {
|
|
for _, contest := range participant.(*Participant).Contests {
|
|
if response.ContestID == contest.ID {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if !found {
|
|
toBeDeletedResponses = append(toBeDeletedResponses, response)
|
|
}
|
|
found = false
|
|
}
|
|
|
|
if len(toBeDeletedResponses) > 0 {
|
|
for _, response := range toBeDeletedResponses {
|
|
if err := db._db.Unscoped().Delete(response).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
|
|
return participant.(*Participant), nil
|
|
}
|
|
}
|
|
|
|
func (model *Participant) Delete(db *Database, args map[string]string, w http.ResponseWriter, r *http.Request) (interface{}, error) {
|
|
participant, err := model.Read(db, args, w, r)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db._db.Unscoped().Delete(participant.(*Participant)).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return participant.(*Participant), nil
|
|
}
|
|
|
|
func CreateParticipant(db *Database, participant *Participant) (*Participant, error) {
|
|
if err := db._db.Where([]uint(participant.ContestIDs)).Find(&participant.Contests).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
if err := db._db.Create(participant).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return participant, nil
|
|
}
|
|
|
|
func SaveParticipant(db *Database, participant interface{}) (interface{}, error) {
|
|
participant.(*Participant).FiscalCode = strings.ToUpper(participant.(*Participant).FiscalCode)
|
|
|
|
if err := db._db.Omit("Category", "School", "Creator", "Updater").Save(participant).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
return participant, nil
|
|
}
|