oef/orm/participant.go

package orm

import (
	"fmt"

	"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 setFlashMessage(w http.ResponseWriter, r *http.Request, key string) error {
// 	session, err := store.Get(r, "flash-session")
// 	if err != nil {
// 		return err
// 	}
// 	session.AddFlash(i18n.FlashMessages[key][config.Config.Language])
// 	err = session.Save(r, w)
// 	if err != nil {
// 		return err
// 	}
// 	return nil
// }

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 {
		return nil, nil
	}
	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
		if user, err := participant.exists(db); err == nil && user != nil {
			if err := db._db.Where("user_id = ?", user.ID).Find(&participant).Error; err != nil {
				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(getUserIDFromToken(r))
			if err != nil {
				return nil, err
			}
			participant.SchoolID = uint(schoolID)
		}

		// Check if a participant of the same category exists
		var school School
		if err := db._db.First(&school, participant.SchoolID).Error; err != nil {
			return nil, err
		}
		hasCategory, err := school.HasCategory(db, participant)
		if err != nil {
			return nil, err
		}
		if hasCategory {
			return nil, errors.CategoryExists
		}

		WriteCreator(r, participant)

		participant, err = CreateParticipant(db, participant)
		if err != nil {
			return nil, err
		}

		// FIXME: Should be managed by API
		if isAdministrator(r) {
			var response Response

			if err := db._db.First(&response, &Response{ParticipantID: participant.ID}).Error; err != nil {
				return nil, err
			}

			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"]

	// 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)) != getUserIDFromToken(r) {
			// setFlashMessage(w, r, "notAuthorized")
			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("School").Preload("School.Participants").Preload("Responses").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(getUserIDFromToken(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("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 {
				// err := setFlashMessage(w, r, "participantExists")
				// if err != nil {
				// 	return nil, err
				// }
				return participant, nil
			}
		} else if err != nil {
			return nil, err
		}

		// Check if a participant of the same category exists
		var school School
		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

			if err := db._db.First(&response, &Response{ParticipantID: participant.(*Participant).ID}).Error; err != nil {
				return nil, err
			}

			response.UpdaterID = getUserIDFromTokenAsUint(r)

			if err := db._db.Save(&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").Save(participant).Error; err != nil {
		return nil, err
	}
	return participant, nil
}